home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 5 / Amiga Tools 5.iso / tools / developer-tools / andere sprachen / oberonv4 / oberon-src / system / opt.mod (.txt) < prev    next >
Encoding:
Oberon Text  |  1995-06-10  |  34.9 KB  |  854 lines
  1. Syntax24.Scn.Fnt
  2. Syntax10.Scn.Fnt
  3. Courier8.Scn.Fnt
  4. (* Notify Ralf for maintenance of Non-FPU source *)
  5. MODULE OPT; (* NW, RC 6.3.89 / 7.1.93 *)
  6.  IMPORT
  7.   OPS, OPM;
  8.  CONST
  9.   MaxConstLen* = OPS.MaxStrLen;
  10.   HdPtrName* = "@ptr";
  11.   HdProcName* = "@proc";
  12.   HdTProcName* = "@tproc";
  13.  TYPE
  14.   Const* = POINTER TO ConstDesc;
  15.   Object* = POINTER TO ObjDesc;
  16.   Struct* = POINTER TO StrDesc;
  17.   Node* = POINTER TO NodeDesc;
  18.   ConstExt* = POINTER TO OPS.String;
  19.   ConstDesc* = RECORD
  20.    ext*: ConstExt; (* string or code for code proc *)
  21.    intval*: LONGINT; (* constant value or adr, proc par size, text position or least case label *)
  22.    intval2*: LONGINT; (* string length, proc var size or larger case label *)
  23.    setval*: SET; (* constant value, procedure body present or "ELSE" present in case *)
  24.    realval*: LONGREAL (* real or longreal constant value *)
  25.   END ;
  26.   ObjDesc* = RECORD
  27.    left*, right*, link*, scope*: Object;
  28.    name*: OPS.Name;
  29.    leaf*: BOOLEAN;
  30.    mode*, mnolev*: SHORTINT; (* mnolev < 0 -> mno = -mnolev *)
  31.    vis*: SHORTINT; (* 0: internal; 1: external; 2: externalR *)
  32.    typ*: Struct;
  33.    conval*: Const;
  34.    adr*, linkadr*: LONGINT
  35.   END ;
  36.   StrDesc* = RECORD
  37.    form*, comp*, mno*, extlev*: SHORTINT;
  38.    ref*, sysflag*: INTEGER;
  39.    n*, size*, tdadr*, offset*, txtpos*: LONGINT;
  40.    BaseTyp*: Struct;
  41.    link*, strobj*: Object
  42.   END ;
  43.   NodeDesc* = RECORD
  44.    left*, right*, link*: Node;
  45.    class*, subcl*: SHORTINT;
  46.    readonly*: BOOLEAN;
  47.    typ*: Struct;
  48.    obj*: Object;
  49.    conval*: Const
  50.   END ;
  51.  (* Objects:
  52.     mode  | adr   linkadr  conval  link     scope    leaf
  53.     -----------------------------------------------------
  54.     Undef |                                                 Not used
  55.     Var   | vno                    next                     Imported var
  56.     Var   | adr   vno              next              regopt Glob or loc var or proc value parameter
  57.     VarPar| vadr                   next              regopt Procedure var parameter
  58.     Con   |                val                              Constant
  59.     Fld   | off                    next                     Record field
  60.     Typ   |                                                 Named type
  61.     LProc |                sizes   firstpar scope    leaf   Local procedure
  62.     XProc | pno            sizes   firstpar scope    leaf   External procedure
  63.     SProc | fno            sizes                            Standard procedure
  64.     CProc |                code    firstpar scope           Code procedure
  65.     IProc | pno            sizes            scope    leaf   Interrupt procedure
  66.     Mod   | key                             scope           Module
  67.     Head  | txtpos                 owner    firstvar        Scope anchor
  68.     TProc | index          sizes   firstpar scope    leaf   Bound procedure, index = 10000H*mthno+pno
  69.                                                     
  70.   Structures:
  71.     form    comp  | n      BaseTyp   link     mno  tdadr  offset txtpos   sysflag
  72.     -----------------------------------------------------------------------------
  73.     Undef   Basic |
  74.     Byte    Basic |
  75.     Bool    Basic |
  76.     Char    Basic |
  77.     SInt    Basic |
  78.     Int     Basic |
  79.     LInt    Basic |
  80.     Real    Basic |
  81.     LReal   Basic |
  82.     Set     Basic |
  83.     String  Basic |
  84.     NilTyp  Basic |
  85.     NoTyp   Basic |
  86.     Pointer Basic |        PBaseTyp           mno                txtpos   sysflag
  87.     ProcTyp Basic |        ResTyp    params   mno                txtpos   sysflag
  88.     Comp    Array | nofel  ElemTyp            mno                txtpos   sysflag
  89.     Comp    DynArr| dim    ElemTyp            mno         lenoff txtpos   sysflag
  90.     Comp    Record| nofmth RBaseTyp  fields   mno  tdadr  tdno   txtpos   sysflag  Glob or loc
  91.     Comp    Record| nofmth RBaseTyp  fields   mno  tdno          txtpos   sysflag  Imported
  92. Nodes:
  93. design   = Nvar|Nvarpar|Nfield|Nderef|Nindex|Nguard|Neguard|Ntype|Nproc.
  94. expr     = design|Nconst|Nupto|Nmop|Ndop|Ncall.
  95. nextexpr = NIL|expr.
  96. ifstat   = NIL|Nif.
  97. casestat = Ncaselse.
  98. sglcase  = NIL|Ncasedo.
  99. stat     = NIL|Ninittd|Nenter|Nassign|Ncall|Nifelse|Ncase|Nwhile|Nrepeat|
  100.            Nloop|Nexit|Nreturn|Nwith|Ntrap.
  101.               class     subcl     obj      left      right     link      
  102.               ---------------------------------------------------------
  103. design        Nvar                var                          nextexpr
  104.               Nvarpar             varpar                       nextexpr
  105.               Nfield              field    design              nextexpr
  106.               Nderef                       design              nextexpr
  107.               Nindex                       design    expr      nextexpr
  108.               Nguard                       design              nextexpr (typ = guard type)
  109.               Neguard                      design              nextexpr (typ = guard type)
  110.               Ntype               type                         nextexpr
  111.               Nproc     normal    proc                         nextexpr
  112.                         super     proc                         nextexpr
  113. expr          design
  114.               Nconst              const                                 (val = node^.conval)
  115.               Nupto                        expr      expr      nextexpr 
  116.               Nmop      not                expr                nextexpr
  117.                         minus              expr                nextexpr
  118.                         is        tsttype  expr                nextexpr
  119.                         conv               expr                nextexpr
  120.                         abs                expr                nextexpr
  121.                         cap                expr                nextexpr
  122.                         odd                expr                nextexpr
  123.                         adr                expr                nextexpr SYSTEM.ADR
  124.                         cc                 Nconst              nextexpr SYSTEM.CC
  125.                         val                expr                nextexpr SYSTEM.VAL
  126.               Ndop      times              expr      expr      nextexpr
  127.                         slash              expr      expr      nextexpr
  128.                         div                expr      expr      nextexpr
  129.                         mod                expr      expr      nextexpr
  130.                         and                expr      expr      nextexpr
  131.                         plus               expr      expr      nextexpr
  132.                         minus              expr      expr      nextexpr
  133.                         or                 expr      expr      nextexpr
  134.                         eql                expr      expr      nextexpr
  135.                         neq                expr      expr      nextexpr
  136.                         lss                expr      expr      nextexpr
  137.                         leq                expr      expr      nextexpr
  138.                         grt                expr      expr      nextexpr
  139.                         geq                expr      expr      nextexpr
  140.                         in                 expr      expr      nextexpr
  141.                         ash                expr      expr      nextexpr
  142.                         msk                expr      Nconst    nextexpr
  143.                         len                design    Nconst    nextexpr
  144.                         bit                expr      expr      nextexpr SYSTEM.BIT
  145.                         lsh                expr      expr      nextexpr SYSTEM.LSH
  146.                         rot                expr      expr      nextexpr SYSTEM.ROT
  147.               Ncall               fpar     design    nextexpr  nextexpr
  148. nextexpr      NIL
  149.               expr
  150. ifstat        NIL
  151.               Nif                          expr      stat      ifstat
  152. casestat      Ncaselse                     sglcase   stat            (minmax = node^.conval)
  153. sglcase       NIL
  154.               Ncasedo                      Nconst    stat      sglcase
  155. stat          NIL
  156.               Ninittd                                          stat     (of node^.typ)
  157.               Nenter              proc     stat      stat      stat     (proc=NIL for mod)
  158.               Nassign   assign             design    expr      stat
  159.                         newfn              design              stat
  160.                         incfn              design    expr      stat
  161.                         decfn              design    expr      stat
  162.                         inclfn             design    expr      stat
  163.                         exclfn             design    expr      stat
  164.                         copyfn             design    expr      stat
  165.                         getfn              design    expr      stat     SYSTEM.GET
  166.                         putfn              expr      expr      stat     SYSTEM.PUT
  167.                         getrfn             design    Nconst    stat     SYSTEM.GETREG
  168.                         putrfn             Nconst    expr      stat     SYSTEM.PUTREG
  169.                         sysnewfn           design    expr      stat     SYSTEM.NEW
  170.                         movefn             expr      expr      stat     SYSTEM.MOVE
  171.                                                                         (right^.link = 3rd par)
  172.               Ncall               fpar     design    nextexpr  stat
  173.               Nifelse                      ifstat    stat      stat
  174.               Ncase                        expr      casestat  stat
  175.               Nwhile                       expr      stat      stat
  176.               Nrepeat                      stat      expr      stat
  177.               Nloop                        stat                stat 
  178.               Nexit                                            stat 
  179.               Nreturn             proc     nextexpr            stat     (proc = NIL for mod)
  180.               Nwith                        ifstat    stat      stat
  181.               Ntrap                                  expr      stat
  182.  CONST
  183.   maxImps = 31; (* must be < 128 *)
  184.   topScope*: Object;
  185.   undftyp*, bytetyp*, booltyp*, chartyp*, sinttyp*, inttyp*, linttyp*,
  186.   realtyp*, lrltyp*, settyp*, stringtyp*, niltyp*, notyp*, sysptrtyp*: Struct;
  187.   nofGmod*: SHORTINT; (*nof imports*)
  188.   GlbMod*:  ARRAY maxImps OF Object; (* GlbMod[i]^.mode = exported module number *)
  189.   SYSimported*: BOOLEAN;
  190.  CONST
  191.   (* object modes *)
  192.   Var = 1; VarPar = 2; Con = 3; Fld = 4; Typ = 5; LProc = 6; XProc = 7;
  193.   SProc = 8; CProc = 9; IProc = 10; Mod = 11; Head = 12; TProc = 13;
  194.   (* structure forms *)
  195.   Undef = 0; Byte = 1; Bool = 2; Char = 3; SInt = 4; Int = 5; LInt = 6;
  196.   Real = 7; LReal = 8; Set = 9; String = 10; NilTyp = 11; NoTyp = 12;
  197.   Pointer = 13; ProcTyp = 14; Comp = 15;
  198.   (* composite structure forms *)
  199.   Basic = 1; Array = 2; DynArr = 3; Record = 4;
  200.   (*function number*)
  201.   assign = 0;
  202.   haltfn = 0; newfn = 1; absfn = 2; capfn = 3; ordfn = 4;
  203.   entierfn = 5; oddfn = 6; minfn = 7; maxfn = 8; chrfn = 9;
  204.   shortfn = 10; longfn = 11; sizefn = 12; incfn = 13; decfn = 14;
  205.   inclfn = 15; exclfn = 16; lenfn = 17; copyfn = 18; ashfn = 19; assertfn = 32;
  206.   (*SYSTEM function number*)
  207.   adrfn = 20; ccfn = 21; lshfn = 22; rotfn = 23;
  208.   getfn = 24; putfn = 25; getrfn = 26; putrfn = 27;
  209.   bitfn = 28; valfn = 29; sysnewfn = 30; movefn = 31;
  210.   (* module visibility of objects *)
  211.   internal = 0; external = 1; externalR = 2;
  212.   firstStr = 16;
  213.   maxStruct = 255; (* must be < 256 *)
  214.   maxUndPtr = 64;
  215.   NotYetExp = 0;
  216.   universe, syslink: Object;
  217.   strno, udpinx: INTEGER;
  218.   nofExp: SHORTINT;
  219.   undPtr: ARRAY maxUndPtr OF Struct;
  220.  PROCEDURE Init*;
  221.  BEGIN topScope := universe; strno := 0; udpinx := 0; nofGmod := 0; SYSimported := FALSE
  222.  END Init;
  223.  PROCEDURE Close*;
  224.   VAR i: INTEGER;
  225.  BEGIN i := 0;
  226.   WHILE i < maxImps DO GlbMod[i] := NIL; INC(i) END (* garbage collection *)
  227.  END Close;
  228.  PROCEDURE err(n: INTEGER);
  229.  BEGIN OPM.err(n)
  230.  END err;
  231.  PROCEDURE NewConst*(): Const;
  232.   VAR const: Const;
  233.  BEGIN NEW(const); (*const^.ext := NIL;*) RETURN const
  234.  END NewConst;
  235.  PROCEDURE NewObj*(): Object;
  236.   VAR obj: Object;
  237.  BEGIN NEW(obj); (*obj^.left := NIL; obj^.right := NIL; obj^.link := NIL; obj^.scope := NIL; *)
  238.   (*obj^.typ := NIL; obj^.conval := NIL;*) RETURN obj
  239.  END NewObj;
  240.  PROCEDURE NewStr*(form, comp: SHORTINT): Struct;
  241.   VAR typ: Struct;
  242.  BEGIN NEW(typ); (*typ^.link := NIL; typ^.strobj := NIL;*)
  243.   typ^.form := form; typ^.comp := comp;
  244.   (*typ^.mno := 0; typ^.ref := 0; typ^.sysflag := 0; typ^.extlev := 0; typ^.n := 0;*)
  245.   typ^.tdadr := OPM.TDAdrUndef; typ^.offset := OPM.TDAdrUndef;
  246.   typ^.txtpos := OPM.errpos; typ^.size := -1; typ^.BaseTyp := undftyp; RETURN typ
  247.  END NewStr;
  248.  PROCEDURE NewNode*(class: SHORTINT): Node;
  249.   VAR node: Node;
  250.  BEGIN
  251.   NEW(node); node^.class := class; (*node^.left := NIL; node^.right := NIL; node^.link := NIL;*)
  252.   (*node^.typ := NIL; node^.obj := NIL; node^.conval := NIL;*)
  253.   RETURN node
  254.  END NewNode;
  255.  PROCEDURE NewExt*(): ConstExt;
  256.   VAR ext: ConstExt;
  257.  BEGIN NEW(ext); RETURN ext
  258.  END NewExt;
  259.  PROCEDURE FindImport*(mod: Object; VAR res: Object);
  260.   VAR obj: Object;
  261.  BEGIN obj := mod^.scope;
  262.   LOOP
  263.    IF obj = NIL THEN EXIT END ;
  264.    IF OPS.name < obj^.name THEN obj := obj^.left
  265.    ELSIF OPS.name > obj^.name THEN obj := obj^.right
  266.    ELSE (*found*)
  267.     IF (obj^.mode = Typ) & (obj^.vis = internal) THEN obj := NIL END ;
  268.     EXIT
  269.    END
  270.   END ;
  271.   res := obj
  272.  END FindImport;
  273.  PROCEDURE Find*(VAR res: Object);
  274.   VAR obj, head: Object;
  275.  BEGIN head := topScope;
  276.   LOOP obj := head^.right;
  277.    LOOP
  278.     IF obj = NIL THEN EXIT END ;
  279.     IF OPS.name < obj^.name THEN obj := obj^.left
  280.     ELSIF OPS.name > obj^.name THEN obj := obj^.right
  281.     ELSE (*found*) EXIT
  282.     END
  283.    END ;
  284.    IF obj # NIL THEN EXIT END ;
  285.    head := head^.left;
  286.    IF head = NIL THEN EXIT END
  287.   END ;
  288.   res := obj
  289.  END Find;
  290.  PROCEDURE FindField*(name: OPS.Name; typ: Struct; VAR res: Object);
  291.   VAR obj: Object;
  292.  BEGIN 
  293.   WHILE typ # NIL DO obj := typ^.link;
  294.    WHILE obj # NIL DO
  295.     IF name < obj^.name THEN obj := obj^.left
  296.     ELSIF name > obj^.name THEN obj := obj^.right
  297.     ELSE (*found*) res := obj; RETURN
  298.     END
  299.    END ;
  300.    typ := typ^.BaseTyp
  301.   END ;
  302.   res := NIL
  303.  END FindField;
  304.  PROCEDURE Insert*(name: OPS.Name; VAR obj: Object);
  305.   VAR ob0, ob1: Object; left: BOOLEAN;
  306.  BEGIN ob0 := topScope; ob1 := ob0^.right; left := FALSE;
  307.   LOOP
  308.    IF ob1 # NIL THEN
  309.     IF name < ob1^.name THEN ob0 := ob1; ob1 := ob0^.left; left := TRUE
  310.     ELSIF name > ob1^.name THEN ob0 := ob1; ob1 := ob0^.right; left := FALSE
  311.     ELSE (*double def*) err(1); ob0 := ob1; ob1 := ob0^.right
  312.     END
  313.    ELSE (*insert*) ob1 := NewObj(); ob1^.leaf := TRUE;
  314.     IF left THEN ob0^.left := ob1 ELSE ob0^.right := ob1 END ;
  315.     ob1^.left := NIL; ob1^.right := NIL; COPY(name, ob1^.name);
  316.     ob1^.mnolev := topScope^.mnolev; EXIT
  317.    END
  318.   END ;
  319.   obj := ob1
  320.  END Insert;
  321.  PROCEDURE OpenScope*(level: SHORTINT; owner: Object);
  322.   VAR head: Object;
  323.  BEGIN head := NewObj();
  324.   head^.mode := Head; head^.mnolev := level; head^.link := owner;
  325.   IF owner # NIL THEN owner^.scope := head END ;
  326.   head^.left := topScope; head^.right := NIL; head^.scope := NIL; topScope := head
  327.  END OpenScope;
  328.  PROCEDURE CloseScope*;
  329.  BEGIN topScope := topScope^.left
  330.  END CloseScope;
  331.  PROCEDURE InsertImport(obj, root: Object; VAR old: Object);
  332.   VAR ob0, ob1: Object; left: BOOLEAN;
  333.  BEGIN ob0 := root; ob1 := ob0^.right; left := FALSE;
  334.   LOOP
  335.    IF ob1 # NIL THEN
  336.     IF obj^.name < ob1^.name THEN ob0 := ob1; ob1 := ob1^.left; left := TRUE
  337.     ELSIF obj^.name > ob1^.name THEN ob0 := ob1; ob1 := ob1^.right; left := FALSE
  338.     ELSE old := ob1; EXIT
  339.     END
  340.    ELSE ob1 := obj;
  341.     IF left THEN ob0^.left := ob1 ELSE ob0^.right := ob1 END ;
  342.     ob1^.left := NIL; ob1^.right := NIL; ob1^.mnolev := root^.mnolev; old := NIL; EXIT
  343.    END
  344.   END
  345.  END InsertImport;
  346.  PROCEDURE ReadId(VAR name: ARRAY OF CHAR; VAR len: LONGINT);
  347.   VAR i: INTEGER; ch: CHAR;
  348.  BEGIN i := 0;
  349.   REPEAT
  350.    OPM.SymRCh(ch); name[i] := ch; INC(i)
  351.   UNTIL ch = 0X;
  352.   len := i
  353.  END ReadId;
  354.  PROCEDURE WriteId(VAR name: ARRAY OF CHAR);
  355.   VAR i: INTEGER; ch: CHAR;
  356.  BEGIN i := 0;
  357.   REPEAT ch := name[i]; OPM.SymWCh(ch); INC(i)
  358.   UNTIL ch = 0X
  359.  END WriteId;
  360.  PROCEDURE Import*(VAR aliasName, impName, selfName: OPS.Name);
  361.   VAR i, m, s, class: INTEGER;
  362.     k, len: LONGINT; rval: REAL;
  363.     ch: CHAR; done: BOOLEAN;
  364.     nofLmod, strno, parlev, fldlev: INTEGER;
  365.     obj, head, old: Object;
  366.     typ: Struct;
  367.     ext: ConstExt;
  368.     mname: OPS.Name;
  369.     LocMod:  ARRAY maxImps + 1 OF Object;
  370.     struct:  ARRAY maxStruct OF Struct;
  371.     param, lastpar, fldlist, lastfld: ARRAY 6 OF Object;
  372.   PROCEDURE reverseList(p: Object; mnolev: SHORTINT);
  373.    VAR q, r: Object;
  374.   BEGIN q := NIL;
  375.    WHILE p # NIL DO p^.mnolev := mnolev;
  376.     r := p^.link; p^.link := q; q := p; p := r
  377.    END
  378.   END reverseList;
  379.  BEGIN nofLmod := 0; strno := firstStr;
  380.   parlev := -1; fldlev := -1;
  381.   IF impName = "SYSTEM" THEN SYSimported := TRUE;
  382.    Insert(aliasName, obj); obj^.mode := Mod; obj^.mnolev := 0; obj^.scope := syslink;
  383.    obj^.adr := 0; obj^.typ := notyp
  384.   ELSE OPM.OldSym(impName, FALSE, done);
  385.    IF done THEN
  386.     struct[Undef] := undftyp; struct[Byte] := bytetyp;
  387.     struct[Bool] := booltyp;  struct[Char] := chartyp;
  388.     struct[SInt] := sinttyp;  struct[Int] := inttyp;
  389.     struct[LInt] := linttyp;  struct[Real] := realtyp;
  390.     struct[LReal] := lrltyp;  struct[Set] := settyp;
  391.     struct[String] := stringtyp; struct[NilTyp] := niltyp;
  392.     struct[NoTyp] := notyp;
  393.     struct[Pointer] := sysptrtyp;
  394.     NEW(head); (*for bound procedures*)
  395.     LOOP (*read next item from symbol file*)
  396.      OPM.SymRTag(class);
  397.      IF OPM.eofSF() THEN EXIT END ;
  398.      IF (class < 8) OR (class = 23) OR (class = 25) THEN (*object*)
  399.       obj := NewObj(); m := 0;
  400.       OPM.SymRTag(s); obj^.typ := struct[s];
  401.       CASE class OF
  402.          1:
  403.         obj^.mode := Con; obj^.conval := NewConst();
  404.         CASE obj^.typ^.form OF
  405.           Byte, Char:
  406.           OPM.SymRCh(ch); obj^.conval^.intval := ORD(ch)
  407.         | SInt, Bool:
  408.           OPM.SymRCh(ch); i := ORD(ch);
  409.           IF i > OPM.MaxSInt THEN i := i + 2*OPM.MinSInt END ;
  410.           obj^.conval^.intval := i
  411.         | Int:
  412.           OPM.SymRInt(obj^.conval^.intval)
  413.         | LInt:
  414.           OPM.SymRLInt(obj^.conval^.intval)
  415.         | Set:
  416.           OPM.SymRSet(obj^.conval^.setval)
  417.         | Real:
  418.           OPM.SymRReal(rval); obj^.conval^.realval := rval;
  419.           obj^.conval^.intval := OPM.ConstNotAlloc
  420.         | LReal:
  421.           OPM.SymRLReal(obj^.conval^.realval);
  422.           obj^.conval^.intval := OPM.ConstNotAlloc
  423.         | String:
  424.           obj^.conval^.ext := NewExt();
  425.           ReadId(obj^.conval^.ext^, obj^.conval^.intval2);
  426.           obj^.conval^.intval := OPM.ConstNotAlloc
  427.         | NilTyp:
  428.           obj^.conval^.intval := OPM.nilval
  429.         END
  430.       | 2, 3:
  431.         obj^.mode := Typ; OPM.SymRTag(m);
  432.         IF obj^.typ^.strobj = NIL THEN obj^.typ^.strobj := obj END ;
  433.         IF class = 2 THEN obj^.vis := external ELSE obj^.vis := internal END
  434.       | 4, 23:
  435.         obj^.mode := Var;
  436.         IF OPM.ExpVarAdr THEN OPM.SymRLInt(obj^.adr)
  437.         ELSE OPM.SymRTag(s); obj^.adr := s
  438.         END ;
  439.         IF class = 23 THEN obj^.vis := externalR ELSE obj^.vis := external END
  440.       | 5, 6, 7, 25:
  441.         obj^.conval := NewConst();
  442.         IF class = 5 THEN obj^.mode := IProc; OPM.SymRTag(s); obj^.adr := s
  443.         ELSIF class = 6 THEN obj^.mode := XProc; OPM.SymRTag(s); obj^.adr := s
  444.         ELSIF class = 7 THEN  obj^.mode := CProc; ext := NewExt(); obj^.conval^.ext := ext;
  445.          OPM.SymRCh(ch); s := ORD(ch); ext^[0] := ch; i := 1; obj^.adr := 0;
  446.          WHILE i <= s DO OPM.SymRCh(ext^[i]); INC(i) END
  447.         ELSE obj^.mode := TProc; obj^.vis := external; OPM.SymRTag(s); typ := struct[s];
  448.          OPM.SymRTag(i); OPM.SymRTag(s); obj^.adr := 10000H*i + s
  449.         END ;
  450.         obj^.linkadr := OPM.LANotAlloc; (* link adr *)
  451.         obj^.conval^.intval := -1;
  452.         reverseList(lastpar[parlev], LocMod[0]^.mnolev);
  453.         obj^.link := param[parlev]^.right; DEC(parlev)
  454.       END ;
  455.       ReadId(obj^.name, len);
  456.       IF class = 25 THEN
  457.        head^.right := typ^.link; head^.mnolev := -typ^.mno; InsertImport(obj, head, old); typ^.link := head^.right
  458.       ELSE InsertImport(obj, LocMod[m], old)
  459.       END ;
  460.       IF (old # NIL) & (obj^.mode = Typ) THEN struct[s] := old^.typ END
  461.      ELSIF class < 13 THEN (*structure*)
  462.       typ := NewStr(Undef, Basic); OPM.SymRTag(s); typ^.BaseTyp := struct[s];
  463.       OPM.SymRTag(s); typ^.mno := -LocMod[s]^.mnolev;
  464.       CASE class OF
  465.         8:
  466.         typ^.form := Pointer; typ^.size := OPM.PointerSize; typ^.n := 0
  467.       | 9:
  468.         typ^.form := ProcTyp; typ^.size := OPM.ProcSize; 
  469.         reverseList(lastpar[parlev], -typ^.mno);
  470.         typ^.link := param[parlev]^.right; DEC(parlev)
  471.       | 10:
  472.         typ^.form := Comp; typ^.comp := Array; OPM.SymRLInt(typ^.size);
  473.         typ^.n := typ^.size DIV typ^.BaseTyp^.size
  474.       | 11:
  475.         typ^.form := Comp; typ^.comp := DynArr;
  476.         OPM.SymRLInt(typ^.size); OPM.SymRInt(typ^.offset);
  477.         IF typ^.BaseTyp^.comp = DynArr THEN typ^.n := typ^.BaseTyp^.n + 1
  478.         ELSE typ^.n := 0
  479.         END
  480.       | 12:
  481.         typ^.form := Comp; typ^.comp := Record;
  482.         OPM.SymRLInt(typ^.size); typ^.n := 0;
  483.         reverseList(lastfld[fldlev], -typ^.mno); typ^.link := fldlist[fldlev]^.right; DEC(fldlev);
  484.         IF typ^.BaseTyp = notyp THEN typ^.BaseTyp := NIL; typ^.extlev := 0
  485.         ELSE typ^.extlev := typ^.BaseTyp^.extlev + 1
  486.         END ;
  487.         OPM.SymRInt(typ^.tdadr)
  488.       END ;
  489.       struct[strno] := typ; INC(strno)
  490.      ELSIF class = 13 THEN (*parameter list start*)
  491.       obj := NewObj(); obj^.mode := Head; obj^.right := NIL;
  492.       IF parlev < 5 THEN INC(parlev); param[parlev] := obj; lastpar[parlev] := NIL
  493.       ELSE err(229)
  494.       END
  495.      ELSIF class < 16 THEN (*parameter*)
  496.       obj := NewObj();
  497.       IF class = 14 THEN obj^.mode := Var ELSE obj^.mode := VarPar END ;
  498.       OPM.SymRTag(s); obj^.typ := struct[s];
  499.       IF OPM.ExpParAdr THEN OPM.SymRLInt(obj^.adr) END ;
  500.       ReadId(obj^.name, len);
  501.       obj^.link := lastpar[parlev]; lastpar[parlev] := obj;
  502.       IF param[parlev]^.right = NIL THEN param[parlev]^.right := obj END
  503.      ELSIF class = 16 THEN (*start field list*)
  504.       obj := NewObj(); obj^.mode := Head; obj^.right := NIL;
  505.       IF fldlev < 5 THEN INC(fldlev); fldlist[fldlev] := obj; lastfld[fldlev] := NIL
  506.       ELSE err(229)
  507.       END
  508.      ELSIF (class = 17) OR (class = 24) THEN (*field*)
  509.       obj := NewObj(); obj^.mode := Fld; OPM.SymRTag(s);
  510.       obj^.typ := struct[s]; OPM.SymRLInt(obj^.adr);
  511.       ReadId(obj^.name, len);
  512.       obj^.link := lastfld[fldlev]; lastfld[fldlev] := obj;
  513.       InsertImport(obj, fldlist[fldlev], old);
  514.       IF class = 24 THEN obj^.vis := externalR ELSE obj^.vis := external END
  515.      ELSIF (class = 18) OR (class = 19) THEN (*hidden pointer or proc*)
  516.       obj := NewObj(); obj^.mode := Fld; OPM.SymRLInt(obj^.adr);
  517.       IF class = 18 THEN obj^.name := HdPtrName
  518.       ELSE obj^.name := HdProcName
  519.       END ;
  520.       obj^.typ := notyp; obj^.vis := internal;
  521.       obj^.link := lastfld[fldlev]; lastfld[fldlev] := obj;
  522.       IF fldlist[fldlev]^.right = NIL THEN
  523.        fldlist[fldlev]^.right := obj
  524.       END
  525.      ELSIF class = 20 THEN (*fixup pointer typ*)
  526.       OPM.SymRTag(s); typ := struct[s]; OPM.SymRTag(s);
  527.       IF typ^.BaseTyp = undftyp THEN typ^.BaseTyp := struct[s] END
  528.      ELSIF class = 21 THEN (*sysflag*)
  529.       OPM.SymRTag(s); typ := struct[s]; OPM.SymRTag(s); typ^.sysflag := s
  530.      ELSIF class = 22 THEN (*module anchor*)
  531.       OPM.SymRLInt(k); ReadId(mname, len);
  532.       IF mname = selfName THEN err(154) END ;
  533.       i := 0;
  534.       WHILE (i < nofGmod) & (mname # GlbMod[i]^.name) DO
  535.        INC(i)
  536.       END ;
  537.       IF i < nofGmod THEN (*module already present*)
  538.        IF k # GlbMod[i]^.adr THEN err(150) END ;
  539.        obj := GlbMod[i]
  540.       ELSE obj := NewObj();
  541.        IF nofGmod < maxImps THEN GlbMod[nofGmod] := obj; INC(nofGmod)
  542.        ELSE err(227)
  543.        END ;
  544.        obj^.mode := NotYetExp; COPY(mname, obj^.name);
  545.        obj^.adr := k; obj^.mnolev := -nofGmod; obj^.right := NIL
  546.       END ;
  547.       IF nofLmod < maxImps + 1 THEN LocMod[nofLmod] := obj; INC(nofLmod)
  548.       ELSE err(227)
  549.       END
  550.      ELSIF class = 26 THEN (*nof methods*)
  551.       OPM.SymRTag(s); typ := struct[s]; OPM.SymRTag(s); typ^.n := s
  552.      ELSIF class = 27 THEN (*hidden method*)
  553.       obj := NewObj(); obj^.mode := TProc; obj^.name := HdTProcName; obj^.typ := undftyp;
  554.       OPM.SymRTag(s); typ := struct[s]; obj^.mnolev := -typ^.mno;
  555.       OPM.SymRTag(i); OPM.SymRTag(s); obj^.adr := 10000H*i + s;
  556.       obj^.linkadr := OPM.LANotAlloc; obj^.vis := internal;
  557.       obj^.link := NewObj(); obj^.link^.typ := typ; old := typ^.link;
  558.       IF old = NIL THEN typ^.link := obj
  559.       ELSE WHILE old^.left # NIL DO old := old^.left END ;
  560.        old^.left := obj
  561.       END
  562.      END
  563.     END (*LOOP*) ;
  564.     Insert(aliasName, obj);
  565.     obj^.mode := Mod; obj^.scope := LocMod[0]^.right;
  566.     obj^.mnolev  := LocMod[0]^.mnolev; obj^.typ := notyp;
  567.     OPM.CloseOldSym
  568.    END
  569.   END
  570.  END Import;
  571.  PROCEDURE^ OutStr(typ: Struct);
  572.  PROCEDURE^ OutObjs(obj: Object);
  573.  PROCEDURE ^OutFlds(fld: Object; adr: LONGINT; visible: BOOLEAN);
  574.  PROCEDURE OutPars(par: Object);
  575.  BEGIN
  576.   OPM.SymWTag(13);
  577.   WHILE par # NIL DO
  578.    OutStr(par^.typ);
  579.    IF par^.mode = Var THEN OPM.SymWTag(14) ELSE OPM.SymWTag(15) END ;
  580.    OPM.SymWTag(par^.typ^.ref);
  581.    IF OPM.ExpParAdr THEN OPM.SymWLInt(par^.adr) END ;
  582.    WriteId(par^.name); par := par^.link
  583.   END
  584.  END OutPars;
  585.  PROCEDURE OutHdFld(typ: Struct; fld: Object; adr: LONGINT);
  586.   VAR i, n: LONGINT; btyp: Struct;
  587.  BEGIN
  588.   IF typ^.comp = Record THEN OutFlds(typ^.link, adr, FALSE)
  589.   ELSIF typ^.comp = Array THEN btyp := typ^.BaseTyp; n := typ^.n;
  590.    WHILE btyp^.comp = Array DO n := btyp^.n * n; btyp := btyp^.BaseTyp END ;
  591.    IF (btyp^.form = Pointer) OR (btyp^.comp = Record) THEN i := 0;
  592.     WHILE i < n DO OutHdFld(btyp, fld, adr); INC(adr, btyp^.size); INC(i) END
  593.    END
  594.   ELSIF OPM.ExpHdPtrFld & ((typ^.form = Pointer) & (typ^.sysflag = 0) OR (fld^.name = HdPtrName)) THEN
  595.    OPM.SymWTag(18); OPM.SymWLInt(adr)
  596.   ELSIF OPM.ExpHdProcFld & ((typ^.form = ProcTyp) & (typ^.sysflag = 0) OR (fld^.name = HdProcName)) THEN
  597.    OPM.SymWTag(19); OPM.SymWLInt(adr)
  598.   END
  599.  END OutHdFld;
  600.  PROCEDURE OutFlds(fld: Object; adr: LONGINT; visible: BOOLEAN);
  601.  BEGIN
  602.   IF visible THEN OPM.SymWTag(16) END ;
  603.   WHILE (fld # NIL) & (fld^.mode = Fld) DO
  604.    IF (fld^.vis # internal) & visible THEN
  605.     OutStr(fld^.typ);
  606.     IF fld^.vis = external THEN OPM.SymWTag(17) ELSE OPM.SymWTag(24) END ;
  607.     OPM.SymWTag(fld^.typ^.ref); OPM.SymWLInt(fld^.adr); WriteId(fld^.name)
  608.    ELSE OutHdFld(fld^.typ, fld, fld^.adr + adr)
  609.    END ;
  610.    fld := fld^.link
  611.   END
  612.  END OutFlds;
  613.  PROCEDURE OutStr(typ: Struct);
  614.   VAR m, em, r: INTEGER; btyp: Struct; mod: Object;
  615.  BEGIN
  616.   IF typ^.ref = 0 THEN
  617.    m := typ^.mno; btyp := typ^.BaseTyp;
  618.    IF m > 0 THEN mod := GlbMod[m-1]; em := mod^.mode;
  619.     IF em = NotYetExp THEN
  620.      mod^.mode := nofExp; m := nofExp; INC(nofExp);
  621.      OPM.SymWTag(22); OPM.SymWLInt(mod^.adr); WriteId(mod^.name)
  622.     ELSE m := em
  623.     END
  624.    END ;
  625.    CASE typ^.form OF
  626.      Undef .. NoTyp:
  627.    | Pointer:
  628.      OPM.SymWTag(8);
  629.      IF btyp^.ref > 0 THEN OPM.SymWTag(btyp^.ref)
  630.      ELSE OPM.SymWTag(Undef);
  631.       IF udpinx < maxUndPtr THEN undPtr[udpinx] := typ; INC(udpinx) ELSE err(224) END
  632.      END ;
  633.      OPM.SymWTag(m)
  634.    | ProcTyp:
  635.      OutStr(btyp); OutPars(typ^.link); OPM.SymWTag(9);
  636.      OPM.SymWTag(btyp^.ref); OPM.SymWTag(m)
  637.    | Comp:
  638.      IF typ^.comp = Array THEN
  639.       OutStr(btyp); OPM.SymWTag(10); OPM.SymWTag(btyp^.ref);
  640.       OPM.SymWTag(m); OPM.SymWLInt(typ^.size)
  641.      ELSIF typ^.comp = DynArr THEN
  642.       OutStr(btyp); OPM.SymWTag(11); OPM.SymWTag(btyp^.ref); OPM.SymWTag(m);
  643.       OPM.SymWLInt(typ^.size); OPM.SymWInt(typ^.offset)
  644.      ELSE (* typ^.comp = Record *)
  645.       IF btyp = NIL THEN r := NoTyp
  646.       ELSE OutStr(btyp); r := btyp^.ref
  647.       END ;
  648.       OutFlds(typ^.link, 0, TRUE); OPM.SymWTag(12); OPM.SymWTag(r); OPM.SymWTag(m);
  649.       OPM.SymWLInt(typ^.size);
  650.       IF OPM.ExpVarAdr OR (typ^.mno > 0) THEN OPM.SymWInt(typ^.tdadr) ELSE OPM.SymWInt(typ^.offset) END
  651.      END
  652.    END ;
  653.    IF typ^.sysflag # 0 THEN OPM.SymWTag(21); OPM.SymWTag(strno); OPM.SymWTag(typ^.sysflag) END ;
  654.    IF (typ^.comp = Record) & (typ^.n > 0) THEN
  655.     OPM.SymWTag(26); OPM.SymWTag(strno); OPM.SymWTag(SHORT(typ^.n))
  656.    END ;
  657.    IF typ^.strobj # NIL THEN
  658.     IF typ^.strobj^.vis # internal THEN OPM.SymWTag(2) ELSE OPM.SymWTag(3) END ;
  659.     OPM.SymWTag(strno); OPM.SymWTag(m); WriteId(typ^.strobj^.name)
  660.    END ;
  661.    typ^.ref := strno; INC(strno);
  662.    IF strno > maxStruct THEN err(228) END ;
  663.    IF typ^.comp = Record THEN OutObjs(typ^.link) END (*bound procedures*)
  664.   END
  665.  END OutStr;
  666.  PROCEDURE OutTyps(obj: Object);
  667.   VAR strobj: Object;
  668.  BEGIN
  669.   IF obj # NIL THEN
  670.    OutTyps(obj^.left); 
  671.    IF (obj^.vis # internal) & (obj^.mode = Typ) THEN
  672.     IF obj^.typ^.ref = 0 THEN OutStr(obj^.typ) END ;
  673.     strobj := obj^.typ^.strobj;
  674.     IF (strobj # obj) & (strobj # NIL) THEN
  675.      OPM.SymWTag(2); OPM.SymWTag(obj^.typ^.ref); OPM.SymWTag(0); WriteId(obj^.name)
  676.     END
  677.    END ;
  678.    OutTyps(obj^.right)
  679.   END
  680.  END OutTyps;
  681.  PROCEDURE OutObjs(obj: Object);
  682.   VAR f, m: INTEGER; rval: REAL; ext: ConstExt; typ: Struct; k: LONGINT;
  683.  BEGIN
  684.   IF obj # NIL THEN
  685.    OutObjs(obj^.left);
  686.    IF (obj^.vis # internal) OR (obj^.mode = TProc) THEN
  687.     IF obj^.mode = Var THEN
  688.      OutStr(obj^.typ);
  689.      IF obj^.vis = externalR THEN OPM.SymWTag(23) ELSE OPM.SymWTag(4) END ;
  690.      OPM.SymWTag(obj^.typ^.ref);
  691.      IF OPM.ExpVarAdr THEN OPM.SymWLInt(obj^.adr)
  692.      ELSE OPM.SymWTag(SHORT(obj^.linkadr))
  693.      END ;
  694.      WriteId(obj^.name)
  695.     ELSIF obj^.mode = Con THEN
  696.      OPM.SymWTag(1); f := obj^.typ^.form; OPM.SymWTag(f);
  697.      CASE f OF
  698.         Byte, Char:
  699.        OPM.SymWCh(CHR(obj^.conval^.intval))
  700.      | Bool, SInt:
  701.        k := obj^.conval^.intval;
  702.        IF k < 0 THEN k := k - 2*OPM.MinSInt END ;
  703.        OPM.SymWCh(CHR(k))
  704.      | Int:
  705.        OPM.SymWInt(obj^.conval^.intval)
  706.      | LInt:
  707.        OPM.SymWLInt(obj^.conval^.intval)
  708.      | Set:
  709.        OPM.SymWSet(obj^.conval^.setval)
  710.      | Real:
  711.        rval := SHORT(obj^.conval^.realval); OPM.SymWReal(rval)
  712.      | LReal:
  713.        OPM.SymWLReal(obj^.conval^.realval)
  714.      | String:
  715.        WriteId(obj^.conval^.ext^)
  716.      | NilTyp:
  717.      ELSE err(127)
  718.      END ;
  719.      WriteId(obj^.name)
  720.     ELSIF obj^.mode = XProc THEN
  721.      OutStr(obj^.typ); OutPars(obj^.link); OPM.SymWTag(6);
  722.      OPM.SymWTag(obj^.typ^.ref); OPM.SymWTag(SHORT(obj^.adr)); WriteId(obj^.name)
  723.     ELSIF obj^.mode = IProc THEN
  724.      OutStr(obj^.typ); OutPars(obj^.link); OPM.SymWTag(5);
  725.      OPM.SymWTag(obj^.typ^.ref); OPM.SymWTag(SHORT(obj^.adr)); WriteId(obj^.name)
  726.     ELSIF obj^.mode = CProc THEN
  727.      OutStr(obj^.typ); OutPars(obj^.link); OPM.SymWTag(7);
  728.      OPM.SymWTag(obj^.typ^.ref); ext := obj^.conval^.ext;
  729.      m := ORD(ext^[0]); f := 1; OPM.SymWCh(CHR(m));
  730.      WHILE f <= m DO OPM.SymWCh(ext^[f]); INC(f) END ;
  731.      WriteId(obj^.name)
  732.     ELSIF obj^.mode = TProc THEN
  733.      typ := obj^.link^.typ; IF typ^.form = Pointer THEN typ := typ^.BaseTyp END ;
  734.      IF (typ^.BaseTyp # NIL) & (obj^.adr DIV 10000H < typ^.BaseTyp^.n) & (obj^.vis = internal) THEN
  735.       OPM.Mark(109, typ^.txtpos)
  736.       (* hidden and overwriting, not detected in OPP because record exported indirectly or via aliasing *)
  737.      END ;
  738.      IF OPM.ExpHdTProc OR (obj^.vis # internal) THEN
  739.       IF obj^.vis # internal THEN OutStr(obj^.typ); OutPars(obj^.link);
  740.        OPM.SymWTag(25); OPM.SymWTag(obj^.typ^.ref)
  741.       ELSE OPM.SymWTag(27)
  742.       END ;
  743.       OPM.SymWTag(typ^.ref); OPM.SymWTag(SHORT(obj^.adr DIV 10000H));
  744.       OPM.SymWTag(SHORT(obj^.adr MOD 10000H));
  745.       IF obj^.vis # internal THEN WriteId(obj^.name) END
  746.      END
  747.     END
  748.    END ;
  749.    OutObjs(obj^.right)
  750.   END
  751.  END OutObjs;
  752.  PROCEDURE Export*(VAR modName: OPS.Name; VAR newSF: BOOLEAN; VAR key: LONGINT);
  753.   VAR i: INTEGER; done: BOOLEAN;
  754.    oldkey: LONGINT;
  755.    typ: Struct;
  756.  BEGIN
  757.   OPM.NewSym(modName, done);
  758.   IF done THEN strno := firstStr;
  759.    OPM.SymWTag(22); OPM.SymWLInt(key); WriteId(modName); nofExp := 1;
  760.    OutTyps(topScope^.right); OutObjs(topScope^.right); i := 0;
  761.    WHILE i < udpinx DO
  762.     typ := undPtr[i]; undPtr[i] := NIL(*garbage collection*); INC(i); OutStr(typ^.BaseTyp);
  763.     OPM.SymWTag(20); (*fixup*)
  764.     OPM.SymWTag(typ^.ref); OPM.SymWTag(typ^.BaseTyp^.ref)
  765.    END ;
  766.    IF OPM.noerr THEN
  767.     OPM.OldSym(modName, TRUE, done);
  768.     IF done THEN (*compare*)
  769.      IF OPM.EqualSym(oldkey) THEN OPM.DeleteNewSym; newSF := FALSE; key := oldkey
  770.      ELSIF newSF THEN OPM.RegisterNewSym(modName)
  771.      ELSE OPM.DeleteNewSym; err(155)
  772.      END
  773.     ELSE OPM.RegisterNewSym(modName); newSF := TRUE
  774.     END
  775.    ELSE OPM.DeleteNewSym; newSF := FALSE
  776.    END
  777.   ELSE newSF := FALSE
  778.   END
  779.  END Export;
  780.  PROCEDURE InitStruct(VAR typ: Struct; form: SHORTINT);
  781.  BEGIN typ := NewStr(form, Basic); typ^.ref := form; typ^.size := OPM.ByteSize;
  782.   typ^.tdadr := 0; typ^.offset := 0; typ^.strobj := NewObj()
  783.  END InitStruct;
  784.  PROCEDURE EnterBoolConst(name: OPS.Name; value: LONGINT);
  785.   VAR obj: Object;
  786.  BEGIN Insert(name, obj); obj^.conval := NewConst();
  787.   obj^.mode := Con; obj^.typ := booltyp; obj^.conval^.intval := value
  788.  END EnterBoolConst;
  789.  PROCEDURE EnterTyp(name: OPS.Name; form: SHORTINT; size: INTEGER; VAR res: Struct);
  790.   VAR obj: Object; typ: Struct;
  791.  BEGIN Insert(name, obj);
  792.   typ := NewStr(form, Basic); obj^.mode := Typ; obj^.typ := typ; obj^.vis := external;
  793.   typ^.strobj := obj; typ^.size := size; typ^.tdadr := 0; typ^.offset := 0; typ^.ref := form; res := typ
  794.  END EnterTyp;
  795.  PROCEDURE EnterProc(name: OPS.Name; num: INTEGER);
  796.   VAR obj: Object;
  797.  BEGIN Insert(name, obj);
  798.   obj^.mode := SProc; obj^.typ := notyp; obj^.adr := num
  799.  END EnterProc;
  800. BEGIN
  801.  topScope := NIL; OpenScope(0, NIL);  OPM.errpos := 0;
  802.  InitStruct(undftyp, Undef); InitStruct(notyp, NoTyp);
  803.  InitStruct(stringtyp, String); InitStruct(niltyp, NilTyp);
  804.  undftyp^.BaseTyp := undftyp;
  805.  (*initialization of module SYSTEM*)
  806.  EnterTyp("BYTE", Byte, OPM.ByteSize, bytetyp);
  807.  EnterTyp("PTR", Pointer, OPM.PointerSize, sysptrtyp);
  808.  EnterProc("ADR", adrfn);
  809.  EnterProc("CC", ccfn);
  810.  EnterProc("LSH", lshfn);
  811.  EnterProc("ROT", rotfn);
  812.  EnterProc("GET", getfn);
  813.  EnterProc("PUT", putfn);
  814.  EnterProc("GETREG", getrfn);
  815.  EnterProc("PUTREG", putrfn);
  816.  EnterProc("BIT", bitfn);
  817.  EnterProc("VAL", valfn);
  818.  EnterProc("NEW", sysnewfn);
  819.  EnterProc("MOVE", movefn);
  820.  syslink := topScope^.right;
  821.  universe := topScope; topScope^.right := NIL;
  822.  EnterTyp("CHAR", Char, OPM.CharSize, chartyp);
  823.  EnterTyp("SET", Set, OPM.SetSize, settyp);
  824.  EnterTyp("REAL", Real, OPM.RealSize, realtyp);
  825.  EnterTyp("INTEGER", Int, OPM.IntSize, inttyp);
  826.  EnterTyp("LONGINT",  LInt, OPM.LIntSize, linttyp);
  827.  EnterTyp("LONGREAL", LReal, OPM.LRealSize, lrltyp);
  828.  EnterTyp("SHORTINT", SInt, OPM.SIntSize, sinttyp);
  829.  EnterTyp("BOOLEAN", Bool, OPM.BoolSize, booltyp);
  830.  EnterBoolConst("FALSE", 0); (* 0 and 1 are compiler internal representation only *)
  831.  EnterBoolConst("TRUE",  1);
  832.  EnterProc("HALT", haltfn);
  833.  EnterProc("NEW", newfn);
  834.  EnterProc("ABS", absfn);
  835.  EnterProc("CAP", capfn);
  836.  EnterProc("ORD", ordfn);
  837.  EnterProc("ENTIER", entierfn);
  838.  EnterProc("ODD", oddfn);
  839.  EnterProc("MIN", minfn);
  840.  EnterProc("MAX", maxfn);
  841.  EnterProc("CHR", chrfn);
  842.  EnterProc("SHORT", shortfn);
  843.  EnterProc("LONG", longfn);
  844.  EnterProc("SIZE", sizefn);
  845.  EnterProc("INC", incfn);
  846.  EnterProc("DEC", decfn);
  847.  EnterProc("INCL", inclfn);
  848.  EnterProc("EXCL", exclfn);
  849.  EnterProc("LEN", lenfn);
  850.  EnterProc("COPY", copyfn);
  851.  EnterProc("ASH", ashfn);
  852.  EnterProc("ASSERT", assertfn) 
  853. END OPT.
  854.